{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 一、从数据中学习\n",
    "\n",
    "要识别一张图像，先从图像中提取特征量，再用机器学习技术学习这些特征量的模式。\n",
    "\n",
    "何为**特征量**？即：从输入数据（输入图像）中准确地提取**本质数据**（重要的数据）的转换器，通常表示为向量。在计算机视觉领域，常用的特征量包括SIFT、SURF和HOG等。\n",
    "\n",
    "**将一张图像转换成特征量（向量），然后对转换后的特征量进行机器学习（SVM、KNN等分类器）。**\n",
    "\n",
    "机器学习的方法中，由机器从收集到的数据中找出规律性。与从零开始想出算法相比，这种方法可以更高效地解决问题，也能减轻人的负担。但是需要注意的是，将图像转换为向量时使用的特征量仍是由人设计的。对于不同的问题，必须使用合适的特征量（必须设计专门的特征量），才能得到好的结果。比如，为了区分狗的脸部，人们需要考虑与用于识别5的特征量不同的其他特征量。也就是说，即使使用特征量和机器学习的方法，也需要针对不同的问题人工考虑合适的特征量。\n",
    "\n",
    "![image-20230314214816571](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20230314214816571.png)\n",
    "\n",
    "# 二、损失函数\n",
    "\n",
    "损失函数是表示神经网络性能的“恶劣程度”的指标，即当前的神经网络对监督数据在多大程度上不拟合，在多大程度上不一致。\n",
    "\n",
    "损失函数可以使用任意函数，但一般用**均方误差**和**交叉熵误差**等。\n",
    "\n",
    "## 2.1均方误差\n",
    "\n",
    "![image-20230314215149638](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20230314215149638.png)\n",
    "\n",
    "其中，$y_k$表示神经网络的输出，$t_k$表示监督数据，$k$表示数据的维数。\n",
    "\n",
    "通俗点讲，$y_k$就是神经网络预测的结果（不一定准确），$t_k$就是标准答案，把结果和标准答案之间求一个误差，从而判断网络的优劣。\n",
    "\n",
    "如手写数字识别的例子中，$y_k=[0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0]$，$t_k=[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]$，$k=10$\n",
    "\n",
    "均方误差代码实现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "def mean_squared_error(y, t):\n",
    "    return 0.5*np.sum(np.square(y-t))\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2交叉熵\n",
    "\n",
    "![image-20230315095953261](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20230315095953261.png)\n",
    "\n",
    "其中，$log$是指以e为底的自然对数。\n",
    "\n",
    "经过观察该式子可以发现，假如$y_k=[0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0]$，$t_k=[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]$，由于交叉熵损失函数是标签$t_k$与其对应的输出取对数$log(y_k)$相乘，且分类问题标签中只有若干位是1（有效）其他全是0（无效），所以交叉熵误差的值是由正确解标签所对应的输出结果决定的，在这个例子中就是索引为2的数据，损失值$=-log0.6$。\n",
    "\n",
    "下图是$log_ex$的函数图像，经过分析发现，$x$越大（即$y_k$（概率）越大），$y$就越大，从而$-logx$就越小：\n",
    "\n",
    "![image-20230315101559654](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20230315101559654.png)\n",
    "\n",
    "**简而言之，交叉熵就是告诉你，我只要看标准答案对应的输出结果（概率）是多少，如果概率越大，说明输出正确的可能性越大，从而损失值越小。**\n",
    "\n",
    "交叉熵损失函数代码实现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.510825457099338\n"
     ]
    }
   ],
   "source": [
    "def cross_entropy_error(y, label):\n",
    "    delta = 1e-7\n",
    "    tmp = -np.sum(np.multiply(np.log(np.add(y, delta)), label))\n",
    "    return tmp\n",
    "\n",
    "\n",
    "# 测试\n",
    "label = [0, 0, 1, 0, 0, 0, 0, 0, 0, 0]\n",
    "y = [0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0]\n",
    "print(cross_entropy_error(y, label))\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上述代码中加入$delta$的原因是：防止输入为0的时候，出现$log(0)$，计算无法进行。\n",
    "\n",
    "上面讲的是对于一个输入数据（一张图片）输出的损失函数，那么现在数据集中有N个输入数据，就需要用所有单个损失值求一个总的损失值。方法是：把N个数据的全部损失值求和，再求平均。公式如下：\n",
    "\n",
    "![image-20230318084906353](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20230318084906353.png)\n",
    "\n",
    "## 2.3mini-batch学习\n",
    "\n",
    "再MNIST数据集中，训练数据有60000个（有些数据集中数据量会比这大得多），如果将每一个数据都求损失函数并求平均，那计算量将会变得非常大，显然是不现实的。所以就在60000个数据中，随机采取一小部分数据（比如100个）来进行学习。这种学习方法叫做mini-batch方法。\n",
    "\n",
    "下面来编写从训练数据中随机选择指定个数的数据的代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys,os\n",
    "\n",
    "current_file_path = os.path.dirname(os.path.realpath('__file__'))\n",
    "Demo_path = os.path.join(current_file_path, 'Demo')\n",
    "sys.path.append(Demo_path)\n",
    "\n",
    "from dataset.mnist import load_mnist\n",
    "\n",
    "(x_train, label_train), (x_test, label_test) = load_mnist(\n",
    "    normalize=True, flatten=True, one_hot_label=True)\n",
    "\n",
    "#(60000, 784)\n",
    "#(60000, 10)\n",
    "#(10000, 784)\n",
    "#(10000, 10)\n",
    "\n",
    "# 随机抽取数据\n",
    "train_size = x_train.shape[0]  # 总数据量\n",
    "batch_size = 10  # 预抽取数据量\n",
    "# 返回抽取的10个数对应的源数组x_train的下标\n",
    "batch_mask = np.random.choice(train_size, batch_size)\n",
    "x_batch = x_train[batch_mask]\n",
    "label_batch = label_train[batch_mask]\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4mini-batch版的交叉熵损失函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cross_entropy_error(y, label):\n",
    "    if y.ndim == 1:\n",
    "        y = np.reshape(1, y.size)\n",
    "        label = np.reshape(1, label.size)\n",
    "\n",
    "    batch_size = y.shape[0]\n",
    "    return -np.sum(np.multiply(label, np.log(np.add(y, 1e-7))))/batch_size\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上述代码中为什么要先对维度是1的输入数据和标签reshape？因为要和维度大于1的输入数据进行统一，维度为1的数据的shape为(size,)，将其转为(1,size)，方便之后batch_size获取输入数据的条数。\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5损失函数的作用\n",
    "\n",
    "先来看何为“学习”？学习就是指不断地试错，从试错的结果中吸取教训，之后改变之前的观念和认知的过程。\n",
    "\n",
    "在机器学习里，整个过程和上述一致。首先要明确**学习的对象是网络的参数（即权重W）**。再看学习的过程：首先随机/任意确定网络的参数，将数据喂入网络得到输出，一开始得到的结果肯定不尽人意（试错）；将得到的结果和标准答案作比较，即计算损失函数（吸取教训）；最后通过损失函数的值判断当前参数是否满意，从而经过某些计算修改网络参数（改变认知）；上述过程重复多次，直至输出正确率符合预期。\n",
    "\n",
    "关于某些修改网络参数的计算，就是指能够找到使损失函数的值尽可能小的参数的计算。一般为了找到使损失函数尽可能小的地方，就要计算参数的导数，然后以导数为指引，逐步更新参数的值。\n",
    "\n",
    "假设有一个神经网络，我们要关注网络中某一个权重参数。对**该参数的损失函数求导**，这个步骤的意思是“**如果稍微改变这个权重参数的值，损失函数会如何变化**”。<u>如果导数的值为负（此段函数呈现单调递减），通过使该权重参数向正方向改变，可以减小损失函数的值；反过来，如果导数的值为正（此段函数呈现单调递增），则通过使该权重参数向负方向改变，可以减小损失函数的值。当导数变为0时，权重参数停止更新。</u>\n",
    "\n",
    "对于参数为二维的情况，上面的导数就称为“方向导数”（表达的意思都是微小变化率，只是称呼不同）。可以很形象的用下面这张图来理解：\n",
    "\n",
    "![image-20220730104349017](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20220730104349017.png)\n",
    "\n",
    "上图中，显示了对于两个权重参数$(\\theta_0,\\theta_1)$取不同的值，对应的损失函数的值。看起来很像起伏的山峰和山谷，而地形的陡峭程度就是方向导数，而我们的目标就是求出红色箭头所指的地方（即损失函数最小点），对应的参数$\\theta_0$和$\\theta_1$是多少。\n",
    "\n",
    "假如我们现在在图中的\"+\"处（即初始点，初始随机参数），想要找到图中的最低点，不可能一下子就确定它的位置，肯定要从\"+\"处不断摸索，找到当前点处的方向导数下降最快的方向然后移动，而表示导数变化最快的量我们称为“梯度”。所以，找最低点的步骤就归纳为：初始点出发，求梯度，找到方向，移动一小步；循环如上步骤，直到导数为0。\n",
    "\n",
    "<i>**1. 为什么选择损失函数作为更新参数的衡量标准，而不是识别精度？**</i>\n",
    "\n",
    "神经网络更新最重要的一点是： **权重参数的连续微小变化能引起损失函数的连续变化。** 举个例子，假设某神经网络在权重$W_1$下对100张手写数字图片进行识别，成功识别20张，识别精度为20%。现在改变$W_1$中某些参数变为$W_2$，仍成功识别20张，那计算导数（变化率）就导致一些区域内的导数为0，导数为0停止更新，这就导致多处神经元死亡。\n",
    "\n",
    "<i>**2. 为什么使用阶跃函数会导致神经网络停止更新？**</i>\n",
    "\n",
    "跟上述问题一样，阶跃函数在负区间上输出始终为0；在正区间上，输出始终为1。这就造成无论参数怎么改，只要输入不变号，输出就不变。某些区域导数为0，停止更新。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 三、数值微分\n",
    "\n",
    "## 3.1 导数\n",
    "\n",
    "导数公式：\n",
    "\n",
    "![image-20230319203710670](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20230319203710670.png)\n",
    "\n",
    "按照该公式写出计算导数的代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def numerical_diff(f, x):\n",
    "    h = 1e-5\n",
    "    return (f(x+h), f(x))/h"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上述代码看似没有问题，但其中引入了一个非常小的量$h$，python中如果数值过于小，就会省略小数中精细的部分，如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n"
     ]
    }
   ],
   "source": [
    "print(np.float32(1e-46))    # 最小1e-45"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "解决这个问题，就将$h$改为$10^{-4}$。\n",
    "\n",
    "第二个需要改进的地方为：给微小量$h$取值，和对$h$取极限，这两者本身就有误差，前者计算的是两点直线的斜率，后者计算的是某一点的切线斜率。**为了减小这个误差，可以计算函数$f$在$x+h$和$x-h$之间的差分。**\n",
    "\n",
    "改进后的导数计算算法如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def numerical_diff(f,x):\n",
    "    h=1e-4\n",
    "    return (f(x+h)-f(x-h))/(2*h)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来，用这个函数求个简单的导数\n",
    "\n",
    "![image-20230319214009223](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20230319214009223.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhYAAAGdCAYAAABO2DpVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABMH0lEQVR4nO3dd3hUddrG8e9Meg+QBBIIvbcgEDpYYEV0EbsiSscGFtBd191V13XfZe2urIuNZgGsgB0RpUnvhN4JJaGmJ5Nk5rx/HAiyEkhgkjMzuT/XlWszvzlz5jl7MsztKc/PZhiGgYiIiIgb2K0uQERERHyHgoWIiIi4jYKFiIiIuI2ChYiIiLiNgoWIiIi4jYKFiIiIuI2ChYiIiLiNgoWIiIi4jX9lv6HL5eLw4cNERERgs9kq++1FRETkEhiGQXZ2NgkJCdjtpR+XqPRgcfjwYRITEyv7bUVERMQNUlNTqVOnTqnPV3qwiIiIAMzCIiMjK/vtRURE5BJkZWWRmJhY8j1emkoPFmdOf0RGRipYiIiIeJmLXcagizdFRETEbRQsRERExG0ULERERMRtFCxERETEbRQsRERExG0ULERERMRtFCxERETEbcodLA4dOsQ999xDjRo1CAkJoU2bNqxevboiahMREREvU64GWadOnaJ79+5cffXVfPfdd8TGxrJz506qVatWUfWJiIiIFylXsHjhhRdITExkypQpJWMNGjRwe1EiIiLincp1KuTLL7+kY8eO3H777cTFxXHFFVfw7rvvXvA1DoeDrKysc35ERETEN5UrWOzZs4eJEyfSpEkT5s6dy4MPPsgjjzzCtGnTSn3N+PHjiYqKKvnRzKYiIiK+y2YYhlHWhQMDA+nYsSNLly4tGXvkkUdYtWoVy5YtO+9rHA4HDoej5PGZ2dEyMzM1CZmIiIgbTZi/k0Kni7F9mmK3X3iysPLKysoiKirqot/f5brGIj4+npYtW54z1qJFCz7//PNSXxMUFERQUFB53kZERETK6csNh3ll3g4AOjWoTs8msZbUUa5TId27d2f79u3njO3YsYN69eq5tSgREREpuzX7T/HEpxsAGNmjgWWhAsoZLMaOHcvy5cv55z//ya5du5g+fTrvvPMOo0ePrqj6RERE5AJST+Zx3/urKSx20adFTZ66voWl9ZQrWCQnJzNr1ixmzJhB69atef7553n99dcZNGhQRdUnIiIipcgqKGL41FWcyC2kZXwk/76rHX5uvraivMp18aY7lPXiDxERESldsdPFsKmrWLzzODUjg5g9ujvxUSEV9n5l/f7WXCEiIiJexjAM/vbVZhbvPE5IgB+ThiRXaKgoDwULERERLzPll318uPwANhv8+652tK4dZXVJJRQsREREvMiPW9J5/pstAPy5XwuubVXL4orOpWAhIiLiJTYfzuSRmeswDBjYKZGRPT1vvi4FCxERES+QnlXAyGmrySt00r1xDf4+oDU2m7V3gJyPgoWIiIiHyyssZuS01RzJLKBRbBj/HdSBAD/P/Ar3zKpEREQEAJfLYOzH69l0KJPqYYFMHppMVEiA1WWVSsFCRETEg70wdxtzN6cT6GfnnXs7UK9GmNUlXZCChYiIiIf6eNUB3l64B4AXb2tLx/rVLa7o4hQsREREPNDSXcf5y6wUAB7p3YSbrqhtcUVlo2AhIiLiYXYfy+GBD9dQ7DK4MSmBsX2aWF1SmSlYiIiIeJDjOQ6GTllJVkEx7etG8+JtbT3yttLSKFiIiIh4iPxCJyOmrSb1ZD51q4fyzuCOBAf4WV1WuShYiIiIeACny+DRmevYkJpBdGgAU4clExMeZHVZ5aZgISIi4gH+8c0WftiSTqC/nXcHd6RhbLjVJV0SBQsRERGLTV6ylym/7APglduTSPaC20pLo2AhIiJioe9T0kpmK/1Tv+b0T0qwuKLLo2AhIiJikXUHTvHo6dlKB3Wuy/29Glpd0mVTsBAREbHA/hO5jJy2Gkexi2uax/Hcja286rbS0ihYiIiIVLJTuYUMm7KKE7mFtK4dyYSBV+DvobOVlpdvbIWIiIiXKChyct8Hq9lzPJfa0SFMHpJMWJC/1WW5jYKFiIhIJXG5DJ74dAOr9p0iItifKcOSiYsMtrost1KwEBERqSQvzt3O1xuPEOBn4+17OtC0ZoTVJbmdgoWIiEgl+GjFft5auBuAf93Slm6NYyyuqGIoWIiIiFSwn7cd5enZ5hToY/s05dYOdSyuqOIoWIiIiFSglEOZjJ6+FpcBt3WowyO9G1tdUoVSsBAREakgB0/lMXzqKvIKnfRoHMP4W9r4RK+KC1GwEBERqQCncgsZMnklR7MdNKsZwX/vaU+Aj/SquBDf30IREZFKVlDkZOT7q9l9LJf4qGCmDk8mMjjA6rIqhYKFiIiIGzldBg/PWMea/aeIDPZn2vBOxEeFWF1WpVGwEBERcRPDMHhmTgrztqQT6G/nvSHJPtmr4kIULERERNzkPz/t4qMVB7DZ4I272tGpQXWrS6p0ChYiIiJu8MmqVF6ZtwOA525sxXWt4y2uyBoKFiIiIpfp521HeWrWJgAeuqoRg7vWt7YgCylYiIiIXIb1qRk89NFanC6DW9rX5g99m1ldkqUULERERC7R3uO5DJ+6ivwiJ72axvLCrW19vgHWxShYiIiIXIJj2Q4GT17BydxC2tSOYuKgqtEA62L0/4CIiEg55TiKGTZ1Jakn86lbPZTJQ5MJC/K3uiyPoGAhIiJSDkVOFw9+uIaUQ1lUDwtk2vBOxEYEWV2Wx1CwEBERKSPDMHjy840s3nmckAA/Jg9NpkFMmNVleRQFCxERkTJ6ce52vlh7CD+7jf8Oak+7xGirS/I4ChYiIiJlMG3pPiYu2A3A+FvacHXzOIsr8kwKFiIiIhcxZ/0h/vbVZgAe/11T7uiYaHFFnqtcweJvf/sbNpvtnJ/mzZtXVG0iIiKWW7jjGI9/sgHDgMFd6zHmmsZWl+TRyn1vTKtWrfjxxx/PrsBft9eIiIhvWnfgFA98sIZil8Hv28bzt/6tqnwDrIspdyrw9/enVq1aFVGLiIiIx9iZns2w0101ezaJ4dU72mG3K1RcTLmvsdi5cycJCQk0bNiQQYMGceDAgQsu73A4yMrKOudHRETEkx3KyGfw5JVk5BXRLjGat+7pQKC/Lkssi3L9v9S5c2emTp3K999/z8SJE9m7dy89e/YkOzu71NeMHz+eqKiokp/ERF3wIiIinutkbiH3TlrBkcwCGseFM0VdNcvFZhiGcakvzsjIoF69erz66quMGDHivMs4HA4cDkfJ46ysLBITE8nMzCQyMvJS31pERMTtchzFDHp3ORsOZpIQFcxnD3YjITrE6rI8QlZWFlFRURf9/r6sCBYdHU3Tpk3ZtWtXqcsEBQURFKRWpyIi4tkcxU4e+GANGw5mUi00gPdHdFaouASXdcIoJyeH3bt3Ex8f7656REREKp3TZTDu4w0s2XWc0EA/pgzrROO4cKvL8krlChZPPPEECxcuZN++fSxdupSbb74ZPz8/Bg4cWFH1iYiIVCjDMHhmTgrfbDpCgJ+Nt+/toFbdl6Fcp0IOHjzIwIEDOXHiBLGxsfTo0YPly5cTGxtbUfWJiIhUqNd+3MlHKw5gs8Frd7ajZxN9p12OcgWLmTNnVlQdIiIilW7qL3t5Y/5OAP4+oDW/b5tgcUXeTzfliohIlWTO/7EFgLF9mnJvl3oWV+QbFCxERKTKWbD9KI9/sgGAIV3r8Uhvzf/hLgoWIiJSpaw9cIoHP1xLscugf1ICz2r+D7dSsBARkSpjy+Eshk5eSX6Rk15NY3nl9iTN/+FmChYiIlIl7D2ey+DJK8gqKKZDvWq8dU97zf9RAfT/qIiI+LxDGfnc894KjucU0jI+kslDkwkN1PwfFUHBQkREfNrxHAf3vreCQxn5NIwJ4/0RnYgKCbC6LJ+lYCEiIj4rM7+IwZNWsud4LrWjQ/hwZGdiwjV/VUVSsBAREZ+UV1jM8Kmr2HIki5jwID4cqUnFKoOChYiI+BxHsZP7P1jDmv2niAz254MRnWgQE2Z1WVWCgoWIiPiUYqeLR2esZ/FOc6bSqcM70SI+0uqyqgwFCxER8Rkul8GTn2/i+81pBPrZeefejrSvW83qsqoUBQsREfEJhmHw96+38Pnag/jZbUy4+wp6NImxuqwqR8FCRER8wmvzdjB16T4AXrqtLX1b1bK2oCpKwUJERLzeu4v28MZPuwD4+4BW3NK+jsUVVV0KFiIi4tU+WLaP//t2KwB/6NuMwV3rW1tQFadgISIiXuvT1ak8PWczAKOvbsToqzX9udUULERExCt9ueEwT36+EYDh3RvwxLXNLK5IQMFCRES80NzNaYz9eD0uA+7uXJenf98Cm03Tn3sCBQsREfEqC7Yf5eHp63C6DG65ojb/GNBaocKDKFiIiIjXWLr7OPd/sIZCp4sb2sTz4m1tsdsVKjyJgoWIiHiFNftPMnLaahzFLvq0iOO1O9vh76evMU+jPSIiIh5v08FMhk5eRV6hk55NYvjP3e0J9NdXmCfSXhEREY+2LS2LeyevINtRTKcG1Xnn3o4EB/hZXZaUQsFCREQ81u5jOdzz3goy8opolxjN5KHJhAQqVHgyBQsREfFIB07kMejdFRzPKaRlfCTThnUiPMjf6rLkIhQsRETE4xzKyOfu95aTllVAk7hwPhjRiajQAKvLkjJQsBAREY9yJDOfge8s5+CpfOrXCOWjkZ2pER5kdVlSRgoWIiLiMdKzChj4znIOnMyjbvVQZtzXhbjIYKvLknJQsBAREY9w9HSo2HcijzrVQphxXxfio0KsLkvKScFCREQsdyzbwd3vrWDP8VxqR4cwY1QXakcrVHgjBQsREbHUiRwHg95bzq6jOcRHBTNjVBcSq4daXZZcIgULERGxzKncQga9t4Id6TnUjAxixqgu1K2hUOHNFCxERMQSGXlmqNiWlk1sRBDTR3WhfkyY1WXJZVKwEBGRSpeZX8S9k1ay5UgWMeGBzBjVmUax4VaXJW6gYCEiIpUqq6CIwZNXsulQJtXDApk+qguN4yKsLkvcRMFCREQqTXZBEUMmr2RDagbVQgP4aGRnmtZUqPAlChYiIlIpch3FDJuyinUHMogKCeDDkZ1pER9pdVniZgoWIiJS4XIcxQydspLV+08REezPhyM60yohyuqypAJomjgREalQ2QVFDJ2yijW/ChVt6ihU+CoFCxERqTBnrqlYeyCDyGB/PhzZmbZ1oq0uSyqQgoWIiFSIrNOh4sw1FR+N7Ezr2jpS4esULERExO0y881bSjekZhAdGsCHIxQqqorLunjzX//6Fzabjccee8xN5YiIiLfLzC9i8KQVJaFCRyqqlks+YrFq1Srefvtt2rZt6856RETEi2XmFXHv5BVsPJh5uk9FF1om6JbSquSSjljk5OQwaNAg3n33XapVq+bumkRExAtl5BUyaNJyNh4821FToaLquaRgMXr0aG644Qb69Olz0WUdDgdZWVnn/IiIiG85M6FYyqEsaoQFMmNUFzW/qqLKfSpk5syZrF27llWrVpVp+fHjx/Pcc8+VuzAREfEOZ6Y+PzOh2PRRXdSmuwor1xGL1NRUHn30UT766COCg4PL9JqnnnqKzMzMkp/U1NRLKlRERDzPydxC7i4JFUHMUKio8myGYRhlXXj27NncfPPN+Pn5lYw5nU5sNht2ux2Hw3HOc+eTlZVFVFQUmZmZREbqMJmIiLc6lu3g3kkr2JaWTUx4EDPv66xZSn1YWb+/y3UqpHfv3mzatOmcsWHDhtG8eXOefPLJi4YKERHxDelZBdz97nJ2H8slLiLo9NTn4VaXJR6gXMEiIiKC1q1bnzMWFhZGjRo1fjMuIiK+6VBGPne/u5z9J/JIiApm+qgu1I8Js7os8RDqvCkiImV24EQeA99dzqGMfBKrhzB9ZBcSq4daXZZ4kMsOFgsWLHBDGSIi4un2HMvh7ndXkJZVQIOYMKaP6kx8VIjVZYmH0RELERG5qB3p2dz97gqO5zhoEhfORyM7ExdZtrsDpWpRsBARkQvafDiTeyet5GRuIS3iI/lwRCdqhAdZXZZ4KAULEREp1YbUDAZPXklmfhFt60Tx/vBORIcGWl2WeDAFCxEROa81+08ydPIqsh3FtK8bzdThnYgMDrC6LPFwChYiIvIby3afYMS0VeQVOuncoDqThiYTHqSvDLk4/ZWIiMg5Fu04xqj3V+ModtGzSQzv3NuRkEA1QJSyuaTZTUVExDf9sDmNkdPMUHFN8zjeHaxQ4VWKCqyuQMFCRERMs9cd4sGP1lLodHFdq1q8dU8HggMUKrzCsR0w60F4MxmKCy0tRadCRESEj1bs56+zUzAMuKV9bV68tS3+fvpvT6/gcsFHt0LGAfPx7p+g2XWWlaO/GhGRKu7thbv5yywzVAzuWo+Xb0tSqPB0qSvBWWT+brdDt0eg2Q0w0tpQATpiISJSZRmGwavzdjDhp10APHRVI/7Qtxk2m83iyuS8DAN2z4fFr8L+X+Cmt6DdQPO55JHQaZS19Z2mYCEiUgW5XAZ//3oLU5fuA+CP1zXjoasaW1uUnJ/LBdu+hsWvwJH15pg9ALIOnl3Gg8KggoWISBXjdBn86fONfLrG/GJ6fkAr7u1a39qi5LcMAzZ+bB6hOL7dHAsIhQ7DoOtoiKptbX2lULAQEalCCotdjP14Pd9sOoLdBi/dlsStHepYXZacj80G6z40Q0VQFHS+Dzo/AGExVld2QQoWIiJVRH6hkwc/WsOC7ccI8LMxYeAVXNc63uqy5AxHDqyZAkkDz4aHq56C1GsgeQQER1lbXxkpWIiIVAHZBUWMmLaalXtPEhxg5+17O3Jl01iryxKAvJOw8h1Y8Rbkn4L8DOj9tPlc/e7mjxdRsBAR8XGncgsZOmUlGw5mEhHkz+RhySTXr251WZKdDsvfhFWToDDHHKveEGKbW1vXZVKwEBHxYUcy87l30kp2Hc2hWmgAH4zoTOva3nFI3afN/Quseg+KT7fgrtkaeo6DljeB3bu7nSpYiIj4qN3Hchg8aSWHMvKJjwrm/eGdaFIzwuqyBKAw1wwVdZKh5xPQtK9H3TJ6ORQsRER80KaDmQyZspKTuYU0jA3jgxGdqR0dYnVZVdORDeYtoz3GQkI7c6znOGh9C9Tv6TOB4gwFCxERH7N013FGvb+a3EInbWpHMXVYMjXCg6wuq+o5sBwWvQy75pmPDRfc+YH5e3Rd88cHKViIiPiQ71OO8MiM9RQ6XXRrVIN3BnckPEj/1FcawzAnAVv8itl2G8Bmh9a3Qo9x1tZWSfTXJiLiI2auPMCfZ23CZcB1rWrx+l3tNO15ZZs5CLZ/Y/5uD4B2d0OPx8y7PaoIBQsRES9nGAZvLdzDC99vA+Cu5ET+7+Y2+Nl969y9R3IWm9dInLmTo35384hFx2HQdYzHtt2uSAoWIiJezDAM/vntVt5dvBeAB69qxB81Q2nFKyqA9R/BL/+G3s9Am9vM8Q7DoO2dHt92uyIpWIiIeKlip4s/fbGJz05PJvaX61swqlfVOeRuiTNtt5f+B3LSzLG1084Gi8BQ86cKU7AQEfFCBUVOxkxfx49b0/Gz2/jXLW24vWOi1WX5rryTsPJdWDHRbLsNEFkbuj0C7QdbW5uHUbAQEfEymXlFjPrAnPcj0N/OfwZewbWtalldlm/7fIR57QSYF2L2GAtt7wL/QGvr8kAKFiIiXuRIZj5DJq9kR3oOEUH+vDO4I10b1bC6LN+TcQCCIiEk2nzc+UFzbo+e46DVzV7fdrsiKViIiHiJHenZDJm8kiOZBcRFBDFteCdaxEdaXZZvOb4TlrwGGz+GXn+Eq540x5v8Dhr3Abvd2vq8gIKFiIgXWLXvJCOmriKroJiGsWG8P7wTdapV7YsE3epM2+0tcwDDHDu65ezzNpvPtd6uKAoWIiIe7vuUNB6duQ5HsYv2daOZNCSZamE6t+8WB1bA4pdh5w9nx5rdYJ7yqNPRurq8mIKFiIgH+3D5fp6Zk4LLgD4t4pgwsD0hgTq/7zZr3zdDRUnb7bFQs5XVVXk1BQsREQ9kGAavztvBhJ92AWY3zX/c1Bp/P53jv2Qul9luO6YpxDYzx3qMNa+b6P4Y1GhkaXm+QsFCRMTDFDtd/HnWJj5ZbTa+erR3Ex7r00TdNC+VsxhSPoclr8KxbdD6NrhtkvlcTGO4cYK19fkYBQsREQ+SX+hkzPS1zN92FLsNnr+pNYM617O6LO9UVAAbpsOS1yFjvzkWFGUemTAMXYxZQRQsREQ8xMncQkZMW8W6AxkE+duZoMZXl27t+/DT/51tux0aA10fguSREBxlbW0+TsFCRMQDHDiRx9ApK9lzPJeokAAmDelIx/rVrS7Le+WdMEPFr9tuV/E5PCqLgoWIiMXWp2YwYuoqTuQWkhAVzLThnWhSM8LqsrxHzlFY9ibU7QrNrjPHOo4wj1K0vVNttyuZgoWIiIV+2JzGIzPXUVDkolVCJJOHJlMzMtjqsrxDxgH45Q1Y9wEUF8CeBdC0r3ntRHAktL/X6gqrJAULERGLTP1lL899vQXDgCubxvLmoPaEB+mf5Yv6ddttV7E5VicZej5hbV0CKFiIiFQ6l8vgn99u5b0lewEY2CmR5weoR0WZ/DweFr5ASdvtBldCz8ehQS/d5eEhFCxERCpRQZGTsR+v57sU826FP/RtxkNXNVKPigtxuc5O/lWrDWBAs+uhxzhITLa0NPmtcsXjiRMn0rZtWyIjI4mMjKRr16589913FVWbiIhPOZlbyN3vLue7lDQC/ez8+652jL66sULF+RgG7P4JptwAv7x+drzZ9fDQChg4Q6HCQ5XriEWdOnX417/+RZMmTTAMg2nTpjFgwADWrVtHq1bqrS4iUpp9x3MZOmUl+07kERnszzuDO9KlYQ2ry/I8Z9puL34FDq8zx07the6Pgt3PPHIR19zaGuWCbIZhGJezgurVq/PSSy8xYsSIMi2flZVFVFQUmZmZREZGXs5bi4h4hTX7TzHq/dWczC2kdnQI04Yn0zhOt5Oe43/bbgP4h0DHYdB1DETVtrY+KfP39yVfY+F0Ovn000/Jzc2la9eupS7ncDhwOBznFCYiUlV8n3KER2eux1Hsok3tKCYN7UhchG4n/Y0f/gorJpq/B0VCp/ugy4MQFmNtXVJu5Q4WmzZtomvXrhQUFBAeHs6sWbNo2bJlqcuPHz+e55577rKKFBHxNoZh8N7ivfzzu60YBvRuHseEu68gNFDXzANQmAuFeRAeaz7uMARSPjPDhNpue7VynwopLCzkwIEDZGZm8tlnn/Hee++xcOHCUsPF+Y5YJCYm6lSIiPisIqeLZ+akMGNlKgD3dqnHs/1b6nZSgPxTsPJdWD4RmvWDm/579rniQnXJ9GBlPRVy2ddY9OnTh0aNGvH222+7tTAREW+UmVfEQ9PX8MuuE9hs8PQNLRnWvb7u/DjTdnvVJCjMNsdimsEDSxQmvESFX2NxhsvlOueIhIhIVbX/RC7Dp65i97FcQgP9mDDwCnq3qGl1WdbKSIWlb5izjRYXmGNxraDnOGh5E/jp1JCvKdcefeqpp+jXrx9169YlOzub6dOns2DBAubOnVtR9YmIeIWVe09y/werOZVXRHxUMJOGJNMyQUdl2TADVr5j/l67I/R6Apr0PdvwSnxOuYLF0aNHGTx4MEeOHCEqKoq2bdsyd+5cfve731VUfSIiHm/WuoM8+dkmCp0u2taJ4r3BHYmrqhOJHdkIriKo3cF83GkUHFprXpSptttVwmVfY1FeusZCRHyFy2Xw2o87mPDTLgCua1WL1+5sR0ign8WVWeDAClj8Muz8wZwQbMQ8hQgfU2nXWIiIVEUFRU6e+HQDX288AsADVzbij32bYbdXoS9Tw4A9P8OiV2D/EnPMZofoelCUD4Gh1tYnllCwEBEpp2PZDu77YDXrDmTgb7fxz1vacEfHRKvLqlx7F8G8Z+HwWvOxPQDaDYTuj0GNRpaWJtZSsBARKYftadkMn7qKQxn5RIUE8NY9HejaqArO+ZF73AwV/iHQYSh0e1httwVQsBARKbN5W9J5bOY6cgud1K8RyuShyTSMDbe6rIpX7ID108E/CNrdbY61HAB9noN2g852zxRBwUJE5KIMw2Diwt28NHc7hgFdGlZn4qAOVAvz8cZOhbmwZiosnQDZRyC8FrS6BQKCzZlGezxmdYXigRQsREQuoKDIyZOfb2TO+sMA3NOlLs/2b0WAL7fnzs843Xb7v5B/0hyLSIDuj1halngHBQsRkVKkZxVw3/ur2XAwEz+7jb/d2Ip7u9SzuqyKtekz+Oqxs223qzWAHmMh6S7zVIjIRShYiIicx4bUDO77YDXpWQ6iQwP476D2dGvko1N4G8bZnhMxTcxQEdcSej6utttSbvprERH5H3PWH+KPn23EUeyiSVw47w3pSL0aYVaX5X7Hd8GS1yAgBG542RyLTzKbW9XuqLbbckkULERETnO5DF6Zt503f94NQO/mcbx+VzsiggMsrszN0jbB4ldg82zAAL9AuOpPEHb6iExiJyurEy+nYCEiAuQ4ihn78XrmbUkH4P4rG/LHvs3x86VOmgdWmIFi568mjmzazzzlEeajp3mk0ilYiEiVl3oyj1Hvr2ZbWjaB/nb+dUsbbmlfx+qy3GvNNPjq9F0dNrt522iPsVCrtbV1ic9RsBCRKm3pruOMnr6WU3lFxEYE8c69HbiibjWry7p8Lpd5q+iZIxHNfw/znoGWN6rttlQoBQsRqZIMw2DyL/v457dbcboM2tSO4p3BHYiPCrG6tMvjLIbNs2DJqxBSHYZ9Y46H1YCxmyGoCnQKFUspWIhIlVNQ5OSpLzYxa90hAG5pX5t/3tyG4AAvnu78TNvtX16HU/vMsaBIyDx0dg4PhQqpBAoWIlKlHMrI5/4PVpNyKAs/u42/XN+CYd3rY7N56UWa/9t2GyC0BnR5CJJHQki0ldVJFaRgISJVxrLdJxg9fS0ncwupHhbIf+6+wvubXm37Bub+2fz9TNvt9oMh0Af7bohXULAQEZ9nGAZTl+7jH9+Y11O0Sojk7Xs7UKdaqNWllV/OUTi5F+p2Nh+3usU8BdLqZrXdFo+gYCEiPq2gyMmfZ23ii7Xm9RQ3X1Gb8bd44fUUGamw9A1Y+z6ExsAj68A/0Gy3PXi21dWJlFCwEBGfdTgjn/s/WMOmQ+YkYk/1a86IHg2863qKM223N84EV7E5FlETctIhOtHa2kTOQ8FCRHzS8j0nGP3RWk7kFlItNIA3725Pt8ZedD3F8V3w8//BltlguMyxBr3MLpkNrjw7aZiIh1GwEBGfcqY/xfhvt1LsMmgZb15PkVjdy66nKMiEzV+Yv59pu52YbG1NImWgYCEiPiPXUcyTn2/k643mbZc3JiXwwq1tCQn08OspDAP2LIATu6DTKHOsTge45mloep3abotXUbAQEZ+w62gOD3y4hl1Hc/C32/jrDS0Y0s3D+1O4XLDjO3NisENrwD8YWg6A8Djz+V5PWFufyCVQsBARr/ftpiP84dMN5BY6qRkZxH8HtadDvepWl1W6X7fdPrrFHPMPgQ5DzAnCRLyYgoWIeK0ip4sXvtvGe0v2AtClYXUmDGxPbIQH93I4uBo+HwmnzJoJijQ7ZHZ5CMJjra1NxA0ULETEKx3NKmDM9HWs3HcSgPuvbMgfrm2Gv5+H/xd/VCJkHT7ddvtBSB6lttviUxQsRMTrrNx7ktHT13Is20F4kD8v357Eda1rWV3Wb+VnwKp34eg2uG2SORZRE+75DGp3UNtt8UkKFiLiNQzDYNKSvYz/bhtOl0GzmhFMvKc9DWM9bNbOnKOw/L+w8j0ozDbHuo2BhCvM3xv0sq42kQqmYCEiXiHHUcyTn23km03mraQD2iUw/pY2hAZ60D9jGanmLKNrp0FxgTkW19LsQVGzjbW1iVQSD/pEioic39YjWYz+aC17jucS4Gfjrze0ZHDXep51K+n+pTCt/9m227U7QM8nzD4Udg+/7kPEjRQsRMRjGYbBx6tSefbLzTiKXdSKDObNQe3pUK+a1aWZHNkQFGH+XrsjhNeCGg3VdluqNAULEfFIuY5i/jo7hVnrzFlJr2way2t3tqN6WKDFlQGpK82mVse2wZg15gyj/oFw/yIIq2F1dSKWUrAQEY+zPS2bhz5aw+5jufjZbTx+bVMe6NUIu93CIwBn2m4vfgX2LT49aIPUFVC/u/lQoUJEwUJEPMunq1N5ek4KBUUuakYGMWFgezo1sLCL5v+23Qaw+0PSXdB9LMQ0tq42EQ+kYCEiHiGvsJinZ2/m87UHAejZJIbX7mxHTLjFXTQPr4OZd5u/n2m73XUMRCdaW5eIh1KwEBHL7UzP5qGP1rLzaA52G4zt05TRVze25tRHsQOObDw7RXmdDua05XEt1HZbpAwULETEUl+sPchfZqWQX+QkNiKIf9/Vjm6NYiq/kMJcWDPN7ENRkAGPpZy9ZmLgDN3hIVJGChYiYom8wmKe+3ILH69OBaB74xq8fucVlT+B2Jm228snQt4JcywiHk7sOhssFCpEykzBQkQq3dYjWYyZvpbdx3Kx2eDR3k14+Jom+FXmqY+8k+bRiVXvgSPLHKtWH3qMhaSB4O/BM6SKeDAFCxGpNIZh8MHy/fzjm60UFruIiwji9Tvb0a2xBac+ivLNYOEqgtgWZlOrVjebPSlE5JLpEyQileJUbiF//Hwj87akA3BN8zheuq0tNSrrro8Tu2HnD+ZU5QBRtaH3M1CjkXlxptpui7iFgoWIVLgVe07w2MfrOZJZQKCfnT/1a86w7vUrZ66PtE2w+FXYMhsMF9TrBvFJ5nPdH6n49xepYsoV0cePH09ycjIRERHExcVx0003sX379oqqTUS8XLHTxWvzdjDw3eUcySygQUwYXzzUjeE9GlR8qEhdCdPvhLd6wOYvzFDR9Drw84CW4CI+rFxHLBYuXMjo0aNJTk6muLiYP//5z1x77bVs2bKFsLCwiqpRRLzQ4Yx8Hpu5npX7TgJwa/s6/H1AK8KCKvhAaeZBmPXAuW23W90MPcdBLU1dLlLRyvUJ//777895PHXqVOLi4lizZg29evVya2Ei4r3mbk7jj59tJDO/iPAgf/5xU2tuuqJ25bx5aAwc36m22yIWuaz/dMjMzASgenUL+/iLiMcoKHLyf99s5YPl+wFoWyeKCQOvoF6NCjqi6Sw2r53YPAvueB/sfhAQDLe8A9Ubqu22iAUuOVi4XC4ee+wxunfvTuvWrUtdzuFw4HA4Sh5nZWVd6luKiAfbfDiTx2auZ+fRHADu79WQx69tRqB/BdxtUeyADTNhyWtwaq85tmU2tL7V/L3hle5/TxEpk0sOFqNHjyYlJYUlS5ZccLnx48fz3HPPXerbiIiHc7kM3luyh5fmbqfIaRAbEcTLtydxZdMKmFPj1223sw+bYyHVzTk8Gl3j/vcTkXKzGYZhlPdFY8aMYc6cOSxatIgGDRpccNnzHbFITEwkMzOTyMjI8lcsIh7jcEY+j3+ygWV7zFbY17asyb9ubUv1sAq48yLzELzd89y2290ehg5DIVAXj4tUtKysLKKioi76/V2uIxaGYfDwww8za9YsFixYcNFQARAUFERQkFrjiviarzYc5i+zNpFVUExIgB/P9m/JncmJ7r2NtNhxtrV2ZAJUbwRBEdD9MWh3t9pui3igcgWL0aNHM336dObMmUNERARpaWkAREVFERISUiEFiohnyS4o4tk5m/li3SEAkhKjef3OdjSIceNRg8yD5umOlM9hzCoIqWZOBHbHNAiLU9ttEQ9WrlMhpf2XyJQpUxg6dGiZ1lHWQyki4nlW7TvJ2I/Xc/BUPnYbjLm6MQ/3bkKAn5su0Dyx27wgc8NMcw4PgBteheQR7lm/iFyyCjsVIiJVT5HTxb9/3Ml/F+zCZUBi9RBeu6MdHeu76VbztBRY8qp526jhMsfq9zSbWjW82j3vISKVQscTReSC9hzLYezH69lw0Oxbc2v7OvztxpZEBAe45w1yj8M7V509QtGkrznTaN3O7lm/iFQqBQsROS+Xy2Dasn288P02CopcRIUE8M+b23BD2/jLW7FhQHrK2fbaYTGQdKd5K2mPcRDf9vKLFxHLKFiIyG8cPJXHHz7dWHIbaY/GMbx0e1vioy7jIm2XC3Z8D4tfgUOr4cFlULOl+Vz/CZq2XMRHKFiISAnDMPhkdSrPf72VHId5G+mfb2jBPZ3rXvptpC6nee3E4lfh6GZzzD8Y0jaeDRYKFSI+Q8FCRAA4mlXAU19sYv62owB0rFeNl29Pov6l3kZaXAgbZsAvr8PJPeZYYAR0Gml2ygyPc0/hIuJRFCxEhK82HObpOSlk5BUR6Gfn8WubMrJnQ/zsl9HsylUM8/8OecfNPhRdHoJOo8zfRcRnKViIVGEncwt5ek4K32w8AkDr2pG8ekc7mtaMKP/K8jNg06fQcYR5aiMwFK75CxTmmW23g8LdWruIeCYFC5Eqav7WdJ78fBPHcxz42W2MuboxY65pXP5mVznHYMVEWPkuOLIgoha06G8+13G4+wsXEY+mYCFSxWTmF/GPr7fw6ZqDADSOC+fVO5JoWye6nCs63XZ7zTQozjfHYpuDv9r7i1RlChYiVciPW9L5y+xNpGc5sNlgVM+GjPtdU4ID/Mq+ksI8+O6P57bdTrgCej4Bza7XHR4iVZyChUgVcCq3kL99tZk56w8D0DAmjBdua0vypbTkDgiBtE1mqKjXA3o9brbdduespiLitRQsRHzct5uO8MycFI7nFGI/fZRibHmOUhxcDcv/C79/HYIjzQDR7wXzubpdKqxuEfFOChYiPupYtoNnv0zh201pADStGc6LtyXRLjH64i82DNi7yOySuXehOVarDfQYa/6uQCEipVCwEPExhmHw5YbD/O3LzZzKK8LPbuOhqxox5prGBPlf5CiFYZhttxe9bLbdBrD7Q9u7oPnvK754EfF6ChYiPiQts4C/zt7Ej1vN7pkt4yN58ba2tK4ddfEXFxfCe73NVttgtt1uPxi6PQLRiRVYtYj4EgULER9gGAafrjnI819vIbugmAA/G49c04QHrmp04b4ULifYTx/F8A+E2GZwci8kj4Cuo9V2W0TKTcFCxMvtO57Ln2dtYulucybSpDpRvHhbEs1qXaB7ZmEerJ0Gy96Ee2dBTBNz/HfPw/Uvqe22iFwyBQsRL1XkdPHOoj28MX8njmIXQf52xv6uKSN7NMC/tKMUBZlmh8zl/4U8M4iw8l24/kXz98j4yileRHyWgoWIF1p34BRPfbGJbWnZAPRoHMP/3dyaejVKmYk097gZJs603QaIrgc9HoOkuyunaBGpEhQsRLxIjqOYl+duZ9qyfRgGVAsN4Onft+TmK2pjK61BlcsJb18JWWYLb2KbQ49x0PpW8NM/ASLiXvpXRcRL/LglnafnpHAkswCAW9rX5q83tKR6WOBvFz61zzwiYbOZF2e2Hww7vlPbbRGpcAoWIh7uaFYBf/tqc0mjq7rVQ/nnzW3o0STmtwunb4bFr8LmL2DgTGja1xzvOQ6u/KPabotIhVOwEPFQLpfBzFWpjP9uK9kFxfjZbYzq2ZBHezchJPB/Gl0dXG12ydz+7dmx/UvPBgu/gMorXESqNAULEQ+09UgWf52dwpr9pwDzFtLxt7SlZULk2YUMA/YtNrtknmm7jQ1aDoCej0N828ovXESqPAULEQ+S4yjmtXk7mLp0H06XQWigH09c24wh3erjZz/PaYzvn4L0lNNtt+805/I405NCRMQCChYiHsAwDL7ZdITnv95CepYDgBvaxPPX37cgPirEXMjlhC1zoMm1EBRuXi9x5R9h72Lo/ghE17VwC0RETAoWIhbbcyyHZ7/czOKdxwGoXyOU5wa05sqmseYCxYWwcSYseQ1O7oG+/zTbbYN52qPlAIsqFxH5LQULEYsUFDn578+7eGvhHgqdLgL97Tx0VSMeuLIRwQF+p9tuvw9L34CsQ+aLQqqB33luLxUR8RAKFiIW+HnbUZ75MoXUk/kA9Goay99vbEX9mDDzoswlr8HS/0CeeRSD8FrQ7WHoMNQ8DSIi4qEULEQq0eGMfJ77ajNzN6cDUCsymGf7t+S61rXOds602eDwOjNU/LrtdkCwdYWLiJSRgoVIJSgocvLuoj38d8Fu8ouc+NltjOjRgEd6NyG8IB3m/hk63QfVG5gvuPJJs0Nm69vUdltEvIr+xRKpQIZh8MOWdP7xzZaS0x7J9avx/E2taR5wDOaOg/XTwVUERfnQ/3XzhTVbmT8iIl5GwUKkguw6ms1zX20pudujVmQwT13fnBtrncL2yzhI+RwMl7lwvR66u0NEfIKChYibZRUU8e8fdzJt6T6KXQaBfnZG9WrAQ1c1JuzbMTB7xtmFm1xrdsms28W6gkVE3EjBQsRNXC6Dz9Yc5MW52zieUwhAn+ZxPP37FtSLOX0nR2RtzrbdHgfxSdYVLCJSARQsRNxg7YFTPPflZjYczASgYUwo/26fRps9r0HmnyHmGnPBrqMh6S613RYRn6VgIXIZ0rMKePH77Xy+9iAAkUF2Xmu9l6uPfYh90WZzoaUToNHpYBFa3fwREfFRChYilyCvsJh3F+3lrYXm7aMBFPN/DVO4Je9T/DfvNRcKDIfkEdBltLXFiohUIgULkXJwuQxmrTvES3O3k5ZVAMAVdaOZFjCeyEOLzYVCqkHnB6HzfebvIiJViIKFSBkt33OCf3yzhZRDWUSQR8PoCMb2a8vv28Zj23gPzNsJ3cZAh2Fquy0iVZaChchF7D2ey/hvt/LDlnSqkcVTQT8wNOAH7Fc+Q0DSdeZCrW+Dljep7baIVHkKFiKlyMgr5I35u3h/2T5quE7wjP833BP4M4GuAigGdv8AXe83F/bzV+ttEREULER+o7DYxYfL9/Pv+TuJKjjI3/2+5I7AxfhTDC4gvh30egKa3WB1qSIiHkfBQuQ0l8vg601HeHnudg6czANgYvhMuhWvMBeo193sktnoGnMGUhER+Q17eV+waNEi+vfvT0JCAjabjdmzZ1dAWSKVa8nO49z45hImzfwUx8mDxIQH8s+b29Bp8D+g8e9g2Pcw7Fto3FuhQkTkAsp9xCI3N5ekpCSGDx/OLbfcUhE1iVSalEOZvPDdVor3LOJJvzn0DEphfcKdNBnyX8KC/IG6cM9nVpcpIuI1yh0s+vXrR79+/SqiFpFKs/9ELi/P3U5uyjeM9Z9N+8BdABh2f9olhEOQzhKKiFyKCv/X0+Fw4HA4Sh5nZWVV9FuKlOp4joMJ83dydOXnPOL3GS0CDwBg+AVhaz8YW/dHILquxVWKiHivCg8W48eP57nnnqvotxG5oBxHMe8t3sO7i/aQW+jkT/47aGE/gDMgDL/kEdi6joGImlaXKSLi9So8WDz11FOMGzeu5HFWVhaJiYkV/bYiABQUOZm+ZBvHFr3HioK65BpNaVsnig69/gIn2+DX6T5NCiYi4kYVHiyCgoIICgqq6LcROYej2Mnnv2zh5MKJ3OX8ihhbFitD23FswEyub1MLm80GtLS6TBERn6Mr1MSnFDldfLVsE5k/v8Gtxd8SacsDG+SE1KbD1ffi16aWbhcVEalA5Q4WOTk57Nq1q+Tx3r17Wb9+PdWrV6duXV30JtZwugzmrD9E2ncvMbRwBqE2B9ggI6wh4b3/QHjS7eAXYHWZIiI+r9zBYvXq1Vx99dUlj89cPzFkyBCmTp3qtsJEysLlMvg25QivzdvB7mO53OEXQGiAg2MRLYm69kmiW90I9nL3gRMRkUtU7mBx1VVXYRhGRdQiUmaGYbBs2WIKfn6ZRXlN2e28mujQABr1GElB7b7ENu2jUx4iIhbQNRbiVVwug+WLf8C25FW6FS0HoIn/NmpfNYrhPRsSERwANLe2SBGRKkzBQryC0+li+c9fErL8VboVbwDAZdjYUeNqavf/C482aGZxhSIiAgoW4uGKnS6+2niYom//wh1Fs80xw872uH7U6f8XmtdtZW2BIiJyDgUL8UhFRUV8uXoPbyw5zP4TeSTb2jIg6Bu2x99E/QFP0apWI6tLFBGR81CwEI/icOSz9qu3qbP5LU4UtWd/8SCqhQZwda8BFLUdRNvqtawuUURELkDBQjxCXm42G+ZMoMGOSXTlOAD9/Vdg6/MMd3dtfHoKcxER8XT611osdfLkCbbMeYUW+z+kK5kAHCeaPU2G02bAY4wKj7K4QhERKQ8FC7HEwVN5vLd4L4mrxzPC/hUAR2xxHGhxH0n9H6JTSJjFFYqIyKVQsJBKtXvXDj5etoNJW+04XQa1uJarw1LIbHcfba8bSXxAoNUliojIZVCwkEqxceM6Tv7wEl2z59LJ1YZ3XH+ge+MaPHBlJxo0ugeb2m6LiPgEBQupMC6XwfIVSyhe+Ard8xfgZzPABnXDXXx1Zwfa1NcdHiIivkbBQtwu11HMTz/Po9qqV+nhXGkO2mB7RBfC+zxJ06RrrC1QREQqjIKFuM3hjHymLdvHjBUHuLFoLv8IWIkLGzuqX01cv6do1qST1SWKiEgFU7CQy7bhwCmWzZ3Byn0Z/ORMAmBl9X5si8mn7nWP0jyhpcUViohIZVGwkEvidBn8kHKILfM/pN+p6Txg38/v/OLJr/seI3o24Zrmcdjtfa0uU0REKpmChZRLZn4RX6zaS9qSadxR8Dn97EfADgX2ECLb3siM37eHwFCryxQREYsoWEiZbD2SxfvL9pO5bg5/sU+mtu0E2CHfLxJnp/sJ7/kQwaHVrS5TREQspmAhpSosdvH95jQ+WLaPVftOAdDVHkhtvxPkB8Xg3/1hQjqPgKAIiysVERFPoWAhv5GWWcD0lQf4dkUKNxbMIdkIYq39Jq5rVYt7u3TGyGtESPMbICDY6lJFRMTDKFgIAIZhsHzPST5Yvo/1m7cy3P41X/r9RKi/A4dfGEPvf564uJqnl77V0lpFRMRzKVhUcZl5Rcxad5DpKw+Qf3Q3D/p9xWsBiwiyFQPgqpVEUK8niIuJtbhSERHxBgoWVZBhGKzce5KZq1L5dtMRHMUubvNbyAuB75httwHqdoNej2Nv1BtsNmsLFhERr6FgUYWcyHHw+dqDzFyVyp5juQRSRCEBNK8VQdfWN2JfOgkaXgU9H4d63awuV0REvJCChY9zuQx+2X2cmStT+WFLGkVOF13sW3k+6EuioqpRfPv7JNWJwmazQcf1EJ1odckiIuLFFCx8VFpmAZ+tSeXj1amknswHDK62r+eP4V/ToniruVBOAEQ7zp7qUKgQEZHLpGDhQ/ILnfywJY3P1hzkl13HcRlgx8WtwWt4IuRr4vN3QjHgFwRX3APdH4WImhddr4iISFkpWHg5wzBYte8Un685yDebjpDjKC55Lrl+Nf4Ut5IOG1+DfCAgDJKHQ9cxEFHLuqJFRMRnKVh4qdSTeXy+9iBfrD3EgZN5JeMNo+3c09Kf3t27Ua9GGBQmwaEPoPVt0Pl+UNttERGpQAoWXiS7oIjvNqXx2dqDrNx7smQ8LNCPm1tGcl/ozyRun4LtYCxU+8V8MjAMRq8Cu92iqkVEpCpRsPBwBUVOFmw/xlcbDjN/WzoFRS7AvN6ye6MYBrYO5drs2QSseRcKMs0X+YdA1qGzF2MqVIiISCVRsPBAxU4Xv+w+wZfrD/PD5jSyf3XdRMPYMG5tX4dbm/hRa/N7MH8yFJ0+FRLTFHqMgza3gV+ARdWLiEhVpmDhIVwug9X7T/HlhkN8uymNk7mFJc/FRwXTPymBG5MSaJUQafac2PkjLPvP6QWSzKZWzfvr6ISIiFhKwcJChmGQciiLLzcc4uuNRziSWVDyXI2wQK5vE0//pAQ61quG/fg2OLEIavc3F2jcGzoMNcNEY7XdFhERz6BgUclcLoN1qRnM3ZzG9ylp59zRERHkz7WtanFjuwS6N6qBv58dDq2FTx6GbV9DcLTZcjsowgwS/f9t2XaIiIicj4JFJSh2uli57yRzU9KYuzmdtKyzRyaCA+z0bl6T/kkJXNUsluAAPzAM2P8LLH4Fdv90dkUNekJBlhksREREPJCCRQUpLHaxdPdxvk9J44ct6edcMxEe5M81zePo17oWVzaLJTTwV7vhyEb49glIXWE+tvlB2zug+2MQ17xyN0JERKScFCzcKMdRzJKdx5i7OZ0ft6aTXXD2bo7o0AB+16Im/drUonvjGIL8/c6/ksAwOLjqV223H4Fq9StnA0RERC6TgsVlSj2Zx/yt6czfdpQVe05S6HSVPBcbEUTfVjXp1zqeTg2qE+D3P3dsOItg48dwfCf87jlzrEYjuPltaNBLbbdFRMTrKFiUk9NlsD71FD9uPcpPW4+yPT37nOfr1wild4ua9Gtdi/Z1q2G3n+dujaJ8WPsBLH0DMlMBG1xxL8Q0Np9ve0fFb4iIiEgFULAog+yCIhbvPM6PW9NZsP3YOddL+NltdKxXjd4t4ujdoiYNY8LMPhPnU5AFqyfBsjch95g5FhYH3cZollEREfEJChbn4XQZpBzKZPHOYyzaeZy1+09R7DJKno8M9ueqZnH0bhHHlU1jiQ4NvPhKDyyH6XecbbsdVRd6PArt7oGA4AraEhERkcqlYHHakcx8Fu88zqIdx/hl13FO5RWd83zDmLCSoxId6lX77fUS5+Nygv30RZo1WwE2td0WERGfVmWDRX6hkxV7T5SEiZ1Hc855PiLIn26Na9CzSSy9msRSt0Zo2Vd+ci/88m9IT4ER88xmVkERMOIHqNH4bNgQERHxMZcULN58801eeukl0tLSSEpKYsKECXTq1MndtblVQZGT9akZLN9zguV7TrD2QAaFxWfv4LDboG2daHo1iaFX01iSEqPLdlTi145ugyWvwqbPwHCaYweWQ72u5u+xzdy0NSIiIp6p3MHi448/Zty4cbz11lt07tyZ119/nb59+7J9+3bi4uIqosZL4ih2sv5ABsv3nDwdJE7h+FWQAHNyr15NYunVNJbujWuU7VqJ8zm01uySue3rs2ONekOvJ86GChERkSrAZhiGcfHFzurcuTPJycn85z/mzJoul4vExEQefvhh/vSnP1309VlZWURFRZGZmUlkZOSlVX0ejmInG1IzS45IrNn/2yAREx5El4bV6dqoBl0a1rjwHRxldWA5TO579nGL/uZMowlXXN56RUREPEhZv7/LdcSisLCQNWvW8NRTT5WM2e12+vTpw7Jly877GofDgcPhOKcwdysoctLh+XnkFjrPGY8JD6Rzwxp0bWgGiUaxbggShgEZ+892w6zTCWq1gbhW0GOs2m6LiEiVVq5gcfz4cZxOJzVrnttzoWbNmmzbtu28rxk/fjzPPffcpVdYBsEBfjSOC+fgqXy6NKxBl0Y16NqwOo1iwy8/SJzhcsLWL81THpmHYGyK2X7bboeRP4H/JZ5GERER8SEVflfIU089xbhx40oeZ2VlkZiY6Pb3mTKsE9VCA9wXJM5wFsHGT2DJa3BipzkWEAaH10P97uZjhQoRERGgnMEiJiYGPz8/0tPTzxlPT0+nVq3zz2sRFBREUFDQpVdYRtXD3PzlXpQP6z40bxvNTDXHgqOh8wPQ+X4Ire7e9xMREfEB5bqfMjAwkA4dOjB//vySMZfLxfz58+na1cfufsg4AN/+wQwVYXHwu7+bpz+ufkqhQkREpBTlPhUybtw4hgwZQseOHenUqROvv/46ubm5DBs2rCLqqzx5J2HfYmg5wHwc28w8MlGjsTl9eUCItfWJiIh4gXIHizvvvJNjx47xzDPPkJaWRrt27fj+++9/c0Gn18g6Asv+A6unQHEBPLL27B0f/V6wtDQRERFvU+4+FperovpYlNuZttvrPwLn6dlKa7WB/m9A7fbW1SUiIuKBKqSPhU/IToN5z5zbdjuxi9kls3Efc14PERERuSRVL1j4B8P278xQ0ai32SXzzG2jIiIicll8O1gYBuxfClu/guvGm0cjQqLh969B9YY65SEiIuJmvhksDAN2/QiLXobU5eZY077Q6Grz9za3WVebiIiID/OtYOFymkcnFr8CaRvNMb9A83bRGo2srU1ERKQK8J1gkZEKH9x8btvtjsOg6xiIjLe2NhERkSrCd4JFZIL5v8FRp9tuP6AOmSIiIpXMd4KF3Q/umAZRiRBsYX8MERGRKsx3ggVAzVZWVyAiIlKllWsSMhEREZELUbAQERERt1GwEBEREbdRsBARERG3UbAQERERt1GwEBEREbdRsBARERG3UbAQERERt1GwEBEREbdRsBARERG3UbAQERERt1GwEBEREbdRsBARERG3qfTZTQ3DACArK6uy31pEREQu0Znv7TPf46Wp9GCRnZ0NQGJiYmW/tYiIiFym7OxsoqKiSn3eZlwseriZy+Xi8OHDREREYLPZ3LberKwsEhMTSU1NJTIy0m3r9SS+vo2+vn2gbfQFvr59oG30BRWxfYZhkJ2dTUJCAnZ76VdSVPoRC7vdTp06dSps/ZGRkT75R/Jrvr6Nvr59oG30Bb6+faBt9AXu3r4LHak4QxdvioiIiNsoWIiIiIjb+EywCAoK4tlnnyUoKMjqUiqMr2+jr28faBt9ga9vH2gbfYGV21fpF2+KiIiI7/KZIxYiIiJiPQULERERcRsFCxEREXEbBQsRERFxG68KFm+++Sb169cnODiYzp07s3Llygsu/+mnn9K8eXOCg4Np06YN3377bSVVWn7jx48nOTmZiIgI4uLiuOmmm9i+ffsFXzN16lRsNts5P8HBwZVUcfn97W9/+029zZs3v+BrvGkf1q9f/zfbZ7PZGD169HmX94b9t2jRIvr3709CQgI2m43Zs2ef87xhGDzzzDPEx8cTEhJCnz592Llz50XXW97PckW60DYWFRXx5JNP0qZNG8LCwkhISGDw4MEcPnz4guu8lL/1inKxfTh06NDf1HrddddddL3esg+B834ubTYbL730Uqnr9KR9WJbvh4KCAkaPHk2NGjUIDw/n1ltvJT09/YLrvdTP78V4TbD4+OOPGTduHM8++yxr164lKSmJvn37cvTo0fMuv3TpUgYOHMiIESNYt24dN910EzfddBMpKSmVXHnZLFy4kNGjR7N8+XLmzZtHUVER1157Lbm5uRd8XWRkJEeOHCn52b9/fyVVfGlatWp1Tr1LliwpdVlv24erVq06Z9vmzZsHwO23317qazx9/+Xm5pKUlMSbb7553udffPFF3njjDd566y1WrFhBWFgYffv2paCgoNR1lvezXNEutI15eXmsXbuWp59+mrVr1/LFF1+wfft2brzxxouutzx/6xXpYvsQ4Lrrrjun1hkzZlxwnd60D4Fztu3IkSNMnjwZm83GrbfeesH1eso+LMv3w9ixY/nqq6/49NNPWbhwIYcPH+aWW2654Hov5fNbJoaX6NSpkzF69OiSx06n00hISDDGjx9/3uXvuOMO44YbbjhnrHPnzsb9999foXW6y9GjRw3AWLhwYanLTJkyxYiKiqq8oi7Ts88+ayQlJZV5eW/fh48++qjRqFEjw+Vynfd5b9t/gDFr1qySxy6Xy6hVq5bx0ksvlYxlZGQYQUFBxowZM0pdT3k/y5Xpf7fxfFauXGkAxv79+0tdprx/65XlfNs3ZMgQY8CAAeVaj7fvwwEDBhjXXHPNBZfx1H1oGL/9fsjIyDACAgKMTz/9tGSZrVu3GoCxbNmy867jUj+/ZeEVRywKCwtZs2YNffr0KRmz2+306dOHZcuWnfc1y5YtO2d5gL59+5a6vKfJzMwEoHr16hdcLicnh3r16pGYmMiAAQPYvHlzZZR3yXbu3ElCQgINGzZk0KBBHDhwoNRlvXkfFhYW8uGHHzJ8+PALTrbnbfvv1/bu3UtaWto5+ygqKorOnTuXuo8u5bPsaTIzM7HZbERHR19wufL8rVttwYIFxMXF0axZMx588EFOnDhR6rLevg/T09P55ptvGDFixEWX9dR9+L/fD2vWrKGoqOicfdK8eXPq1q1b6j65lM9vWXlFsDh+/DhOp5OaNWueM16zZk3S0tLO+5q0tLRyLe9JXC4Xjz32GN27d6d169alLtesWTMmT57MnDlz+PDDD3G5XHTr1o2DBw9WYrVl17lzZ6ZOncr333/PxIkT2bt3Lz179iQ7O/u8y3vzPpw9ezYZGRkMHTq01GW8bf/9rzP7oTz76FI+y56koKCAJ598koEDB15wYqfy/q1b6brrruP9999n/vz5vPDCCyxcuJB+/frhdDrPu7y378Np06YRERFx0dMEnroPz/f9kJaWRmBg4G/C7sW+I88sU9bXlFWlz24qFzd69GhSUlIuej6va9eudO3ateRxt27daNGiBW+//TbPP/98RZdZbv369Sv5vW3btnTu3Jl69erxySeflOm/HrzJpEmT6NevHwkJCaUu4237r6orKirijjvuwDAMJk6ceMFlvelv/a677ir5vU2bNrRt25ZGjRqxYMECevfubWFlFWPy5MkMGjToohdKe+o+LOv3g5W84ohFTEwMfn5+v7nCNT09nVq1ap33NbVq1SrX8p5izJgxfP311/z888/lnl4+ICCAK664gl27dlVQde4VHR1N06ZNS63XW/fh/v37+fHHHxk5cmS5Xudt++/MfijPPrqUz7InOBMq9u/fz7x588o9DfXF/tY9ScOGDYmJiSm1Vm/dhwCLFy9m+/bt5f5sgmfsw9K+H2rVqkVhYSEZGRnnLH+x78gzy5T1NWXlFcEiMDCQDh06MH/+/JIxl8vF/Pnzz/kvvl/r2rXrOcsDzJs3r9TlrWYYBmPGjGHWrFn89NNPNGjQoNzrcDqdbNq0ifj4+Aqo0P1ycnLYvXt3qfV62z48Y8qUKcTFxXHDDTeU63Xetv8aNGhArVq1ztlHWVlZrFixotR9dCmfZaudCRU7d+7kxx9/pEaNGuVex8X+1j3JwYMHOXHiRKm1euM+PGPSpEl06NCBpKSkcr/Wyn14se+HDh06EBAQcM4+2b59OwcOHCh1n1zK57c8BXuFmTNnGkFBQcbUqVONLVu2GPfdd58RHR1tpKWlGYZhGPfee6/xpz/9qWT5X375xfD39zdefvllY+vWrcazzz5rBAQEGJs2bbJqEy7owQcfNKKioowFCxYYR44cKfnJy8srWeZ/t/G5554z5s6da+zevdtYs2aNcddddxnBwcHG5s2brdiEi3r88ceNBQsWGHv37jV++eUXo0+fPkZMTIxx9OhRwzC8fx8ahnl1fN26dY0nn3zyN8954/7Lzs421q1bZ6xbt84AjFdffdVYt25dyR0R//rXv4zo6Ghjzpw5xsaNG40BAwYYDRo0MPLz80vWcc011xgTJkwoeXyxz3Jlu9A2FhYWGjfeeKNRp04dY/369ed8Nh0OR8k6/ncbL/a37inbl52dbTzxxBPGsmXLjL179xo//vij0b59e6NJkyZGQUFBqdvnTfvwjMzMTCM0NNSYOHHiedfhyfuwLN8PDzzwgFG3bl3jp59+MlavXm107drV6Nq16znradasmfHFF1+UPC7L5/dSeE2wMAzDmDBhglG3bl0jMDDQ6NSpk7F8+fKS56688kpjyJAh5yz/ySefGE2bNjUCAwONVq1aGd98800lV1x2wHl/pkyZUrLM/27jY489VvL/R82aNY3rr7/eWLt2beUXX0Z33nmnER8fbwQGBhq1a9c27rzzTmPXrl0lz3v7PjQMw5g7d64BGNu3b//Nc964/37++efz/l2e2Q6Xy2U8/fTTRs2aNY2goCCjd+/ev9n2evXqGc8+++w5Yxf6LFe2C23j3r17S/1s/vzzzyXr+N9tvNjfemW60Pbl5eUZ1157rREbG2sEBAQY9erVM0aNGvWbgODN+/CMt99+2wgJCTEyMjLOuw5P3odl+X7Iz883HnroIaNatWpGaGiocfPNNxtHjhz5zXp+/ZqyfH4vhaZNFxEREbfximssRERExDsoWIiIiIjbKFiIiIiI2yhYiIiIiNsoWIiIiIjbKFiIiIiI2yhYiIiIiNsoWIiIiIjbKFiIiIiI2yhYiIiIiNsoWIiIiIjbKFiIiIiI2/w/s2Lrtm/1tJYAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 确定函数式\n",
    "def func(x):\n",
    "    return 0.01*x**2+0.1*x\n",
    "\n",
    "# 求某点的切线\n",
    "def tangent_line(f, x):\n",
    "    gradient = numerical_diff(f, x)  # 切线斜率\n",
    "\n",
    "    def line(_x):\n",
    "        return gradient*(_x-x)+f(x)\n",
    "    \n",
    "    return line #返回一个函数式\n",
    "\n",
    "# 画线\n",
    "x = np.arange(0, 20, 0.1)\n",
    "y1 = func(x)\n",
    "tf=tangent_line(func,5)\n",
    "y2=tf(x)\n",
    "plt.plot(x,y1)\n",
    "plt.plot(x,y2,linestyle='--')\n",
    "plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2偏导数\n",
    "\n",
    "假如现在有如下式子：\n",
    "\n",
    "![image-20230320103225419](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20230320103225419.png)\n",
    "\n",
    "其中有两个变量，下面用代码实现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def func(x):\n",
    "    return x[0]**2+x[1]**2\n",
    "\n",
    "#设置图像为三维格式\n",
    "figure=plt.figure()\n",
    "ax=plt.axes(projection='3d')\n",
    "\n",
    "#确定输入范围\n",
    "X1=np.arange(-10,10,0.1)\n",
    "X2=np.arange(-10,10,0.1)\n",
    "\n",
    "#绘制网格\n",
    "X1,X2=np.meshgrid(X1,X2)\n",
    "\n",
    "#确定表达式\n",
    "Z=X1**2+X2**2\n",
    "\n",
    "#画图\n",
    "ax.plot_surface(X1,X2,Z,cmap='rainbow')\n",
    "plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "求偏导数：待求变量不动，另一个变量看成常数，再对待求变量求导\n",
    "\n",
    "比如，当$x_0=3，x_1=4$时，对$x_0$求偏导数如下：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.00000000000378\n"
     ]
    }
   ],
   "source": [
    "def func_tmp1(x0):\n",
    "    return x0**2+4**2\n",
    "\n",
    "print(numerical_diff(func_tmp1,3))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3梯度\n",
    "\n",
    "求$x_0=3,x_1=4$时，$x_0,x_1$的偏导数为：![image-20230320150135578](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20230320150135578.png)\n",
    "\n",
    "像这样**全部由变量的偏导数汇总而成的向量**称为**梯度**。\n",
    "\n",
    "梯度的实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6. 8.]\n"
     ]
    }
   ],
   "source": [
    "#x是变量的取值，x.size代表变量的个数\n",
    "def numerical_gradient(f,x):\n",
    "    h=1e-4\n",
    "    gradient=np.zeros_like(x) #生成和x一样大小的全零数组\n",
    "\n",
    "    for i in range(x.size):\n",
    "        #计算f(x+h)\n",
    "        #取出其中一个（待求变量）+h，另一个不动\n",
    "        tmp=x[i]\n",
    "        x[i]=tmp+h\n",
    "        f1=f(x)\n",
    "\n",
    "        #计算f(x-h)\n",
    "        x[i]=tmp-h\n",
    "        f2=f(x)\n",
    "\n",
    "        #求差分\n",
    "        gradient[i]=(f1-f2)/(2*h)\n",
    "\n",
    "        #还原\n",
    "        x[i]=tmp\n",
    "    \n",
    "    return gradient\n",
    "\n",
    "#测试\n",
    "print(numerical_gradient(func,np.array([3.0,4.0])))\n",
    "    "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下图为函数$f(x_0,x_1)=x_0^2+x_1^2$的每个取值点的梯度（一个向量），可以观察发现，每个点的梯度都指向该函数的最低处，且离最低处越远，箭头越大。\n",
    "\n",
    "![image-20230320204319480](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20230320204319480.png)\n",
    "\n",
    "实际上，梯度会指向各点处函数值降低的方向；**更严格的说，梯度指示的方向是各点处的函数值减小最多的方向**。这一点非常重要，对于如何在一点能够最快的找到局部函数值最低点有着至关重要的作用，也是下面所讲的梯度下降法的基础。\n",
    "\n",
    "## 3.4梯度法\n",
    "\n",
    "通过使用梯度来寻找函数最小值的方法就是梯度法。\n",
    "\n",
    "需要注意的是，梯度表示的是各点处的函数值减小最多的方向。所以，**梯度所指方向不一定是函数值最小值或真正应该前进的方向**。实际上，在复杂的函数中，梯度指示的方向基本上都不是函数值最小处。\n",
    "\n",
    "虽然梯度的方向并不一定指向最小值，但**沿着它的方向能够最大限度地减小函数的值**。因此，在寻找函数的最小值（或者尽可能小的值）的位置的任务中，要**以梯度的信息为线索**，决定前进的方向。\n",
    "\n",
    "**梯度法**：函数的取值从当前位置沿着梯度方向前进一定距离，然后在新的地方重新求梯度，再沿着新梯度方向前进，如此反复，不断地沿梯度方向前进，从而逐渐减小函数值。\n",
    "\n",
    "下面用表达式来表示梯度法：\n",
    "\n",
    "![image-20230320212036421](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20230320212036421.png)\n",
    "\n",
    "上式中，将一个向量分为两个基向量进行计算，$\\eta$为**学习率**，表示了每次朝梯度方向迈出距离的长短。以下图为例：\n",
    "\n",
    "![image-20220730104349017](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20220730104349017.png)\n",
    "\n",
    "图中可以看出，有多个极小值/局部最小值（洼地），如果每次步子迈的太大，即学习率$\\eta$过大，就可能一步跨过（错过）最小值点，导致一直在找最小值点，模型没办法收敛，这被称为**梯度爆炸**；反之，如果学习率过小，就有可能陷入局部最小值点（极小值点），从而找到的不是全局最小值点。\n",
    "\n",
    "一般的，在训练中，学习率都要实现确定为某个值，比如0.01或0.001。在神经网络的学习中，一般会一边改变学习率的值，一边确认学习是否正确进行了。\n",
    "\n",
    "下面用python实现梯度下降法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_descent(f,x,lr=0.01,step_num=100):\n",
    "    for i in range(step_num):\n",
    "        grad=numerical_gradient(f,x)\n",
    "        x=x-lr*grad\n",
    "\n",
    "    return x"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "尝试用梯度法求如下函数的最小值：\n",
    "\n",
    "![](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20230321125317446.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-6.11110793e-10  8.14814391e-10]\n"
     ]
    }
   ],
   "source": [
    "def func(x):\n",
    "    return x[0]**2 + x[1]**2\n",
    "\n",
    "print(gradient_descent(func,np.array([-3.0,4.0]),0.1,100))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下图是上述梯度下降法的过程，原点处是最低的地方，函数的取值一点点在向其靠近。\n",
    "\n",
    "![image-20230321130636218](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20230321130636218.png)\n",
    "\n",
    "- 如果把学习率调小一点，变成0.01，结果就会像下面这样，步子迈的太小，到不了最小值。\n",
    "\n",
    "![image-20230321130450855](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20230321130450855.png)\n",
    "\n",
    "- 如果学习率太大，调成0.6，就直接跨过最低点。\n",
    "\n",
    "![image-20230321130556992](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20230321130556992.png)\n",
    "\n",
    "## 3.5神经网络的梯度\n",
    "\n",
    "假如此时有一个形状为2×3的权重，下面一行是各参数的偏导数：\n",
    "\n",
    "![image-20230321135158526](https://zyc-learning-1309954661.cos.ap-nanjing.myqcloud.com/machine-learning-pic/image-20230321135158526.png)\n",
    "\n",
    "下面以上述神经网络为例，实现一个SimpleNet类："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# 预先准备：激活函数（softmax），损失函数（cross_entropy_error），梯度计算函数(numerical_gradient)\n",
    "def softmax(x):\n",
    "    max = np.max(x)\n",
    "    tmp = np.sum(np.exp(x-max))\n",
    "    return np.exp(x-max)/tmp\n",
    "\n",
    "\n",
    "def cross_entropy_error(y, label):\n",
    "    if y.ndim == 1:\n",
    "        y = y.reshape(1, y.size)\n",
    "        label = label.reshape(1, label.size)\n",
    "\n",
    "    # 对输入的y进行处理，取batch\n",
    "    batch_size = y.shape[0]\n",
    "\n",
    "    # 交叉熵损失计算的是label（one-hot）中为1的那一位对应的输出，所以找出为1的索引\n",
    "    one_index = np.argmax(label, axiFs=1)\n",
    "\n",
    "    return -np.sum(np.log(np.add(y[0:batch_size, one_index], 1e-7)))/batch_size\n",
    "\n",
    "\n",
    "def numerical_gradient(f, W):\n",
    "    h = 1e-4\n",
    "    grad = np.zeros_like(W)\n",
    "\n",
    "    # 求偏导\n",
    "    # flags=['multi_index']表示追踪iter的下标\n",
    "    iter = np.nditer(W, flags=['multi_index'], op_flags=['readwrite'])\n",
    "    while not iter.finished:\n",
    "        # 获取当前参数的下标\n",
    "        index = iter.multi_index\n",
    "        # 保存当前iter的值\n",
    "        tmp = W[index]\n",
    "        # 求f(x+h)\n",
    "        W[index] = tmp+h\n",
    "        f1 = f(W)\n",
    "        # 求f(x-h)\n",
    "        W[index] = tmp-h\n",
    "        f2 = f(W)\n",
    "        # 求梯度\n",
    "        grad[index] = (f1-f2)/(2*h)\n",
    "        # 还原值\n",
    "        W[index] = tmp\n",
    "        # 继续迭代\n",
    "        iter.iternext()\n",
    "\n",
    "    return grad\n",
    "\n",
    "\n",
    "class SimpleNet:\n",
    "    def __init__(self) -> None:\n",
    "        self.W = np.random.randn(2, 3)\n",
    "\n",
    "    # 前向传播\n",
    "    def predict(self, x):\n",
    "        z = np.dot(x, self.W)\n",
    "        y = softmax(z)\n",
    "\n",
    "        return y\n",
    "\n",
    "    # 计算损失函数\n",
    "    def loss(self, y, label):\n",
    "        return cross_entropy_error(y, label)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 四、学习算法实现"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1学习算法基本步骤\n",
    "\n",
    "**1. 选取数据**\n",
    "\n",
    "从训练数据中随机选出一部分数据，这部分数据称为mini-batch。我们的目标是减小mini-batch的损失函数的值。\n",
    "\n",
    "**2. 前向传播**\n",
    "\n",
    "将mini-batch输入网络，根据计算得到输出。\n",
    "\n",
    "**3. 求梯度**\n",
    "\n",
    "根据（2）中的输出、标签（标准答案）以及损失函数，计算梯度，得到能够使损失函数降低的方向。\n",
    "\n",
    "**4. 更新参数**\n",
    "\n",
    "由（3）中的方向和学习率，更新各个参数值。\n",
    "\n",
    "**5. 重复前三步**\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2两层神经网络的类TwoLayerNet\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'W1': array([[ 0.00151804, -0.00284742, -0.00213414],\n",
       "        [ 0.00303608, -0.00569484, -0.00426828]]),\n",
       " 'b1': array([ 0.00151804, -0.00284742, -0.00213414]),\n",
       " 'W2': array([[ 0.2517775 , -0.2517775 ],\n",
       "        [ 0.24797921, -0.24797921],\n",
       "        [ 0.25181158, -0.25181158]]),\n",
       " 'b2': array([ 0.49650598, -0.49650598])}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "def softmax(x):\n",
    "    max = np.max(x)\n",
    "    tmp = np.sum(np.exp(x-max))\n",
    "    return np.exp(x-max)/tmp\n",
    "\n",
    "\n",
    "def sigmoid(x):\n",
    "    return 1 / (1 + np.exp(-x))\n",
    "\n",
    "\n",
    "def cross_entropy_error(y, label):\n",
    "    if y.ndim == 1:\n",
    "        y = y.reshape(1, y.size)\n",
    "        label = label.reshape(1, label.size)\n",
    "\n",
    "    # 对输入的y进行处理，取batch\n",
    "    batch_size = y.shape[0]\n",
    "\n",
    "    # 交叉熵损失计算的是label（one-hot）中为1的那一位对应的输出，所以找出为1的索引\n",
    "    one_index = label.argmax(axis=1)\n",
    "\n",
    "    return -np.sum(np.log(np.add(y[0:batch_size, one_index], 1e-7)))/batch_size\n",
    "\n",
    "\n",
    "def numerical_gradient(f, W):\n",
    "    h = 1e-4\n",
    "    grad = np.zeros_like(W)\n",
    "\n",
    "    # 求偏导\n",
    "    # flags=['multi_index']表示追踪iter的下标\n",
    "    iter = np.nditer(W, flags=['multi_index'], op_flags=['readwrite'])\n",
    "    while not iter.finished:\n",
    "        # 获取当前参数的下标\n",
    "        index = iter.multi_index\n",
    "        # 保存当前iter的值\n",
    "        tmp = W[index]\n",
    "        # 求f(x+h)\n",
    "        W[index] = tmp+h\n",
    "        f1 = f(W)\n",
    "        # 求f(x-h)\n",
    "        W[index] = tmp-h\n",
    "        f2 = f(W)\n",
    "        # 求梯度\n",
    "        grad[index] = (f1-f2)/(2*h)\n",
    "        # 还原值\n",
    "        W[index] = tmp\n",
    "        # 继续迭代\n",
    "        iter.iternext()\n",
    "\n",
    "    return grad\n",
    "\n",
    "\n",
    "class TwoLayerNet:\n",
    "    # x_size:输入神经元个数；hidden_size中间层神经元个数；y_size输出层神经元个数；weight_init_std\n",
    "    def __init__(self, x_size, hidden_size, y_size, weight_init_std=0.01) -> None:\n",
    "        self.params = {}\n",
    "        self.params['W1'] = weight_init_std * \\\n",
    "            np.random.randn(x_size, hidden_size)  # \\表示两行之间是连接在一起的\n",
    "        self.params['b1'] = np.zeros(hidden_size)\n",
    "        self.params['W2'] = weight_init_std * \\\n",
    "            np.random.randn(hidden_size, y_size)\n",
    "        self.params['b2'] = np.zeros(y_size)\n",
    "\n",
    "    def predict(self, x):\n",
    "        W1, W2 = self.params['W1'], self.params['W2']\n",
    "        b1, b2 = self.params['b1'], self.params['b2']\n",
    "\n",
    "        a1 = np.dot(x, W1)+b1\n",
    "        z1 = sigmoid(a1)\n",
    "        a2 = np.dot(z1, W2)+b2\n",
    "        y = softmax(a2)\n",
    "\n",
    "        return y\n",
    "\n",
    "    def loss(self, x, label):\n",
    "        y = self.predict(x)\n",
    "        return cross_entropy_error(y, label)\n",
    "\n",
    "    def gradient(self, x, label):\n",
    "        # 找loss和W的关系\n",
    "        def loss_W(W):\n",
    "            # 实际上这个loss_W函数的参数W就是给个样子，没什么作用，实际算的就是loss函数\n",
    "            return self.loss(x, label)\n",
    "\n",
    "        grads = {}\n",
    "        grads['W1'] = numerical_gradient(loss_W, self.params['W1']) #列表，字典做形参原数据也会改变\n",
    "        grads['b1'] = numerical_gradient(loss_W, self.params['b1'])\n",
    "        grads['W2'] = numerical_gradient(loss_W, self.params['W2'])\n",
    "        grads['b2'] = numerical_gradient(loss_W, self.params['b2'])\n",
    "\n",
    "        return grads\n",
    "\n",
    "    def accuracy(self,x,label):\n",
    "        y=self.predict(x)\n",
    "        y=np.argmax(y,axis=1)\n",
    "        label=np.argmax(label,axis=1)\n",
    "\n",
    "        return np.sum(y==label)/float(x.shape[0])\n",
    "\n",
    "net = TwoLayerNet(2, 3, 2)\n",
    "net.gradient(np.array([1.0, 2.0]), np.array([0, 1]))\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面解释一下我在看这段代码时的困惑的地方：loss_W(W)中的W没起到实际的作用，为什么在计算梯度函数$numerical\\_gradient$中$f(x+h),f(x-h)$（这里的$f$就是$loss\\_W$）的值不一样？\n",
    "\n",
    "因为在这段代码中：\n",
    "\n",
    "```py\n",
    "def numerical_gradient(f, W):\n",
    "    h = 1e-4\n",
    "    grad = np.zeros_like(W)\n",
    "\n",
    "    # 求偏导\n",
    "    # flags=['multi_index']表示追踪iter的下标\n",
    "    iter = np.nditer(W, flags=['multi_index'], op_flags=['readwrite'])\n",
    "    while not iter.finished:\n",
    "        # 获取当前参数的下标\n",
    "        index = iter.multi_index\n",
    "        # 保存当前iter的值\n",
    "        tmp = W[index]\n",
    "        # 求f(x+h)\n",
    "        W[index] = tmp+h\n",
    "        f1 = f(W)\n",
    "        # 求f(x-h)\n",
    "        W[index] = tmp-h\n",
    "        f2 = f(W)\n",
    "        # 求梯度\n",
    "        grad[index] = (f1-f2)/(2*h)\n",
    "        # 还原值\n",
    "        W[index] = tmp\n",
    "        # 继续迭代\n",
    "        iter.iternext()\n",
    "\n",
    "    return grad\n",
    "```\n",
    "\n",
    "$W$数组是作为形参传进来的，\n",
    "\n",
    "```py\n",
    "    numerical_gradient(loss_W, self.params['W1'])\n",
    "```\n",
    "中的\n",
    "\n",
    "```py\n",
    "    self.params['W1']\n",
    "```\n",
    "\n",
    "作为形参赋给$W$，**函数中改变数组形参的值，原数组的值也会跟着改变**。\n",
    "\n",
    "所以，虽然\n",
    "\n",
    "```py\n",
    "    f1 = f(W)\n",
    "```\n",
    "\n",
    "看似$f1$的取值跟$W$没有关系，但在此之前，神经网络的权重就已经改变了。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.3训练阶段"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[17], line 29\u001b[0m\n\u001b[0;32m     26\u001b[0m label_batch \u001b[38;5;241m=\u001b[39m label_train[batch_mask]\n\u001b[0;32m     28\u001b[0m \u001b[38;5;66;03m# 计算梯度并更新参数\u001b[39;00m\n\u001b[1;32m---> 29\u001b[0m grad \u001b[38;5;241m=\u001b[39m \u001b[43mnetwork\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgradient\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx_batch\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabel_batch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     30\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m key \u001b[38;5;129;01min\u001b[39;00m (\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mW1\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mb1\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mW2\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mb2\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[0;32m     31\u001b[0m     network\u001b[38;5;241m.\u001b[39mparams[key] \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m=\u001b[39m learning_rate\u001b[38;5;241m*\u001b[39mgrad[key]\n",
      "Cell \u001b[1;32mIn[16], line 89\u001b[0m, in \u001b[0;36mTwoLayerNet.gradient\u001b[1;34m(self, x, label)\u001b[0m\n\u001b[0;32m     86\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloss(x, label)\n\u001b[0;32m     88\u001b[0m grads \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m---> 89\u001b[0m grads[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mW1\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[43mnumerical_gradient\u001b[49m\u001b[43m(\u001b[49m\u001b[43mloss_W\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mW1\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m#列表，字典做形参原数据也会改变\u001b[39;00m\n\u001b[0;32m     90\u001b[0m grads[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mb1\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m numerical_gradient(loss_W, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mb1\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[0;32m     91\u001b[0m grads[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mW2\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m numerical_gradient(loss_W, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mW2\u001b[39m\u001b[38;5;124m'\u001b[39m])\n",
      "Cell \u001b[1;32mIn[16], line 42\u001b[0m, in \u001b[0;36mnumerical_gradient\u001b[1;34m(f, W)\u001b[0m\n\u001b[0;32m     40\u001b[0m \u001b[38;5;66;03m# 求f(x+h)\u001b[39;00m\n\u001b[0;32m     41\u001b[0m W[index] \u001b[38;5;241m=\u001b[39m tmp\u001b[38;5;241m+\u001b[39mh\n\u001b[1;32m---> 42\u001b[0m f1 \u001b[38;5;241m=\u001b[39m \u001b[43mf\u001b[49m\u001b[43m(\u001b[49m\u001b[43mW\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     43\u001b[0m \u001b[38;5;66;03m# 求f(x-h)\u001b[39;00m\n\u001b[0;32m     44\u001b[0m W[index] \u001b[38;5;241m=\u001b[39m tmp\u001b[38;5;241m-\u001b[39mh\n",
      "Cell \u001b[1;32mIn[16], line 86\u001b[0m, in \u001b[0;36mTwoLayerNet.gradient.<locals>.loss_W\u001b[1;34m(W)\u001b[0m\n\u001b[0;32m     84\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mloss_W\u001b[39m(W):\n\u001b[0;32m     85\u001b[0m     \u001b[38;5;66;03m# 实际上这个loss_W函数的参数W就是给个样子，没什么作用，实际算的就是loss函数\u001b[39;00m\n\u001b[1;32m---> 86\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mloss\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabel\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[1;32mIn[16], line 79\u001b[0m, in \u001b[0;36mTwoLayerNet.loss\u001b[1;34m(self, x, label)\u001b[0m\n\u001b[0;32m     78\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mloss\u001b[39m(\u001b[38;5;28mself\u001b[39m, x, label):\n\u001b[1;32m---> 79\u001b[0m     y \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpredict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     80\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m cross_entropy_error(y, label)\n",
      "Cell \u001b[1;32mIn[16], line 71\u001b[0m, in \u001b[0;36mTwoLayerNet.predict\u001b[1;34m(self, x)\u001b[0m\n\u001b[0;32m     68\u001b[0m W1, W2 \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mW1\u001b[39m\u001b[38;5;124m'\u001b[39m], \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mW2\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[0;32m     69\u001b[0m b1, b2 \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mb1\u001b[39m\u001b[38;5;124m'\u001b[39m], \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mb2\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[1;32m---> 71\u001b[0m a1 \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mW1\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m+\u001b[39mb1\n\u001b[0;32m     72\u001b[0m z1 \u001b[38;5;241m=\u001b[39m sigmoid(a1)\n\u001b[0;32m     73\u001b[0m a2 \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mdot(z1, W2)\u001b[38;5;241m+\u001b[39mb2\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from dataset.mnist import load_mnist\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 获取数据集\n",
    "(x_train, label_train), (x_test, label_test) = load_mnist(\n",
    "    normalize=True, flatten=True, one_hot_label=True)\n",
    "\n",
    "# 用列表记录每一轮损失值\n",
    "loss_list = []\n",
    "\n",
    "# 设定超参数\n",
    "learning_rate = 0.1\n",
    "batch_size = 100\n",
    "train_size = x_train.shape[0]\n",
    "iter_num = 100  # 迭代次数\n",
    "\n",
    "# 建立网络对象\n",
    "network = TwoLayerNet(x_size=x_train.shape[1], hidden_size=50, y_size=label_train.shape[1])\n",
    "\n",
    "# 开始训练\n",
    "for i in range(iter_num):\n",
    "    # 选取mini-batch\n",
    "    batch_mask = np.random.choice(train_size, batch_size)\n",
    "    x_batch = x_train[batch_mask]\n",
    "    label_batch = label_train[batch_mask]\n",
    "\n",
    "    # 计算梯度并更新参数\n",
    "    grad = network.gradient(x_batch, label_batch)\n",
    "    for key in ('W1', 'b1', 'W2', 'b2'):\n",
    "        network.params[key] -= learning_rate*grad[key]\n",
    "\n",
    "    # 追踪每一轮的损失值\n",
    "    loss = network.loss(x_batch, label_batch)\n",
    "    loss_list.append(loss)\n",
    "\n",
    "# 画出损失值的曲线图\n",
    "time = list(range(1, iter_num+1))\n",
    "plt.plot(time, loss_list, scalex='times', scaley='loss')\n",
    "plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ps：上述代码跑了65分钟，仅仅100轮，实在太慢，没有特殊需求这部分代码别轻易运行。\n",
    "\n",
    "## 4.4测试阶段\n",
    "\n",
    "神经网络的学习中，必须确认是否能够正确识别训练数据以外的其他数据，即确认是否会发生过拟合。\n",
    "\n",
    "**过拟合是指，虽然训练数据中的数字图像能被正确辨别，但是不在训练数据中的数字图像却无法被识别的现象。** 神经网络学习的最初目标是掌握泛化能力，因此，要评价神经网络的泛化能力，就必须使用不包含在训练数据中的数据。\n",
    "\n",
    "【注】：**epoch**：一个epoch是指**学习中所有训练数据均被使用过一次时的更新次数**。比如，对于 10000笔训练数据，用大小为 100笔数据的mini-batch进行学习时，重复随机梯度下降法 100次，所有的训练数据就都被“看过”了A。此时，100次就是一个 epoch。（在训练阶段用的是随机mini-batch选取，所以不能保证每一个数据都能被选到。<u>**一般做法是事先将所有训练数据随机打乱，然后按指定的批次大小，按序生成mini-batch。这样每个mini-batch均有一个索引号，比如此例可以是0, 1, 2, ... , 99，然后用索引号可以遍历所有的mini-batch**</u>）\n",
    "\n",
    "测试阶段要做的事，一般是测试模型的准确度。为测试模型准确度，将训练阶段的代码稍作修改："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from dataset.mnist import load_mnist\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 获取数据集\n",
    "(x_train, label_train), (x_test, label_test) = load_mnist(\n",
    "    normalize=True, flatten=True, one_hot_label=True)\n",
    "\n",
    "train_accurate_list = []\n",
    "test_accurate_list=[]\n",
    "epoch=[]\n",
    "\n",
    "# 超参数\n",
    "train_size = x_train.shape[0]\n",
    "iter_num = 10000\n",
    "batch_size = 100\n",
    "learning_rate = 0.1\n",
    "\n",
    "# 一个epoch需要计算多少轮\n",
    "iter_per_epoch = max(train_size/batch_size, 1)  # 如果train_size<batch_size,则需要1轮\n",
    "\n",
    "network = TwoLayerNet(\n",
    "    x_size=x_train.shape[1], hidden_size=50, y_size=label_train.shape[1])\n",
    "\n",
    "for i in range(iter_num):\n",
    "    # 获取mini-batch\n",
    "    batch_mask = np.random.choice(x_train.shape[0], batch_size)\n",
    "    x_batch = x_train[batch_mask]\n",
    "    label_batch = label_train[batch_mask]\n",
    "\n",
    "    # 计算梯度并更新\n",
    "    grad = network.gradient(x_batch, label_batch)\n",
    "    for key in ('W1', 'b1', 'W2', 'b2'):\n",
    "        network.params[key] -= learning_rate*grad[key]\n",
    "\n",
    "    # 如果已经满一个epoch，也就是每iter_per_epoch轮，就计算准确度\n",
    "    if i%iter_per_epoch ==0:\n",
    "        epoch.append(i/iter_per_epoch)\n",
    "        train_accuracy=network.accuracy(x_train,label_train)\n",
    "        test_accuracy=network.accuracy(x_test,label_test)\n",
    "        train_accurate_list.append(train_accuracy)\n",
    "        test_accurate_list.append(test_accuracy)\n",
    "\n",
    "#画图\n",
    "plt.plot(epoch,train_accuracy)\n",
    "plt.plot(epoch,test_accuracy,linesyle='--')\n",
    "plt.legend(['train_accuracy','test_accuracy'])\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上述代码跑起来太费时间，光正向传播就要把10000+(70000/100)*(10000/600)=21666次batch送到网络中计算，之前100轮总共计算了200次batch花了一个小时。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pythonProject",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
